import { WebSocketServer } from 'ws';

// 创建 WebSocket 服务器实例，监听所有网络接口的 8080 端口
const wss = new WebSocketServer({ host: '0.0.0.0', port: 8080 });

// 存储在线用户
const users = new Map();
// 存储历史消息
const messageHistory = [];

// WebSocket 连接状态常量
const OPEN = 1;

// 生成随机用户ID
function generateUserId() {
    return `用户-${Math.floor(Math.random() * 10000)}`;
}

// 处理新客户端连接
wss.on('connection', (ws, req) => {
    console.log('收到新的连接请求');
    
    let userId = null;
    let userType = 'customer';
    let heartbeatInterval;

    try {
        // 生成用户ID
        userId = generateUserId();
        console.log(`新用户 ${userId} 已连接 (IP: ${req.socket.remoteAddress})`);

        // 设置用户信息
        ws.userId = userId;
        ws.userType = userType;
        ws.isAlive = true;

        // 添加到用户列表
        users.set(userId, ws);

        // 发送注册成功响应
        ws.send(JSON.stringify({ 
            type: 'register', 
            userId,
            userType
        }));

        // 发送历史消息记录
        if (messageHistory.length > 0) {
            ws.send(JSON.stringify({ 
                type: 'history', 
                messages: messageHistory 
            }));
        }

        // 设置心跳检测
        heartbeatInterval = setInterval(() => {
            if (ws.isAlive === false) {
                console.log(`用户 ${userId} 心跳超时，关闭连接`);
                return ws.terminate();
            }
            ws.isAlive = false;
            ws.ping();
        }, 30000);

        // 处理客户端消息
        ws.on('message', (message) => {
            try {
                const data = JSON.parse(message.toString());
                let newMessage;
                
                switch (data.type) {
                    case 'message':
                        // 构造新消息对象
                        newMessage = {
                            type: 'message',
                            fromUserId: userId,
                            fromUserType: userType,
                            message: data.message,
                            timestamp: new Date().toLocaleTimeString(),
                            messageId: data.messageId || `${userId}-${Date.now()}` // 保留客户端传来的消息ID或生成新的
                        };
                        
                        // 保存到历史记录
                        messageHistory.push(newMessage);
                        
                        // 根据用户类型发送消息
                        if (userType === 'customer') {
                            // 如果是客户发送的消息，只发送给客服
                            users.forEach((client) => {
                                if (client.userType === 'service' && client.readyState === OPEN) {
                                    client.send(JSON.stringify(newMessage));
                                }
                            });
                        } else {
                            // 如果是客服发送的消息，只发送给客户
                            users.forEach((client) => {
                                if (client.userType === 'customer' && client.readyState === OPEN) {
                                    client.send(JSON.stringify(newMessage));
                                }
                            });
                        }
                        break;

                    case 'setUserType':
                        userType = data.userType;
                        ws.userType = userType;
                        console.log(`${userId} 设置为 ${userType}`);
                        break;

                    case 'pong':
                        ws.isAlive = true;
                        break;
                }
            } catch (error) {
                console.error(`处理 ${userId} 的消息时出错:`, error);
            }
        });

        // 处理心跳响应
        ws.on('pong', () => {
            ws.isAlive = true;
        });

        // 处理连接错误
        ws.on('error', (error) => {
            console.error(`${userId} 连接错误:`, error);
            clearInterval(heartbeatInterval);
            users.delete(userId);
        });

        // 处理连接关闭
        ws.on('close', () => {
            console.log(`${userId} 已断开连接`);
            clearInterval(heartbeatInterval);
            users.delete(userId);
        });

    } catch (error) {
        console.error('处理新连接时出错:', error);
        if (ws.readyState === OPEN) {
            ws.close();
        }
    }
});

console.log('WebSocket 服务已启动，运行在 ws://0.0.0.0:8080');

// 模拟阿里云短信服务的后端服务器
const express = require('express');
const cors = require('cors');
const bodyParser = require('body-parser');

const app = express();
app.use(cors());
app.use(bodyParser.json());

// 存储验证码的临时数据库
const verificationCodes = {};

// 发送短信验证码接口
app.post('/api/send-sms-code', (req, res) => {
  const { phoneNumber } = req.body;
  
  if (!phoneNumber || !/^1[3-9]\d{9}$/.test(phoneNumber)) {
    return res.json({
      success: false,
      message: '无效的手机号码'
    });
  }

  // 生成6位随机验证码
  const code = Math.floor(100000 + Math.random() * 900000).toString();
  
  // 存储验证码（实际生产环境会通过阿里云SDK发送短信）
  verificationCodes[phoneNumber] = {
    code,
    expireAt: Date.now() + 5 * 60 * 1000  // 5分钟有效期
  };
  
  console.log(`为手机号 ${phoneNumber} 生成验证码: ${code}`);
  
  return res.json({
    success: true,
    message: '验证码已发送'
  });
});

// 验证短信验证码接口
app.post('/api/verify-sms-code', (req, res) => {
  const { phoneNumber, code } = req.body;
  
  if (!phoneNumber || !code) {
    return res.json({
      success: false,
      message: '手机号和验证码不能为空'
    });
  }

  const storedVerification = verificationCodes[phoneNumber];
  
  if (!storedVerification) {
    return res.json({
      success: false,
      message: '验证码不存在或已过期，请重新获取'
    });
  }
  
  if (Date.now() > storedVerification.expireAt) {
    delete verificationCodes[phoneNumber];
    return res.json({
      success: false,
      message: '验证码已过期，请重新获取'
    });
  }
  
  if (storedVerification.code !== code) {
    return res.json({
      success: false,
      message: '验证码错误'
    });
  }
  
  // 验证成功后清除验证码
  delete verificationCodes[phoneNumber];
  
  return res.json({
    success: true,
    message: '验证成功'
  });
});

// 登录成功后的模拟接口
app.post('/api/login', (req, res) => {
  // 模拟用户登录成功的响应
  return res.json({
    success: true,
    message: '登录成功',
    data: {
      token: 'mock-token-' + Date.now(),
      userId: '12345',
      username: 'testuser'
    }
  });
});

const PORT = process.env.PORT || 3010;

app.listen(PORT, () => {
  console.log(`模拟阿里云短信服务器运行在 http://localhost:${PORT}`);
}); 